// ZlibBaseStream.cs
// ------------------------------------------------------------------
//
// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
// All rights reserved.
//
// This code module is part of DotNetZip, a zipfile class library.
//
// ------------------------------------------------------------------
//
// This code is licensed under the Microsoft Public License.
// See the file License.txt for the license details.
// More info on: http://dotnetzip.codeplex.com
//
// ------------------------------------------------------------------
//
// last saved (in emacs):
// Time-stamp: <2011-August-06 21:22:38>
//
// ------------------------------------------------------------------
//
// This module defines the ZlibBaseStream class, which is an intnernal
// base class for DeflateStream, ZlibStream and GZipStream.
//
// ------------------------------------------------------------------

using System;
using System.IO;

namespace Ionic.Zlib
{

  internal enum ZlibStreamFlavor { ZLIB = 1950, DEFLATE = 1951, GZIP = 1952 }

  internal class ZlibBaseStream : System.IO.Stream
  {
    protected internal ZlibCodec _z = null; // deferred init... new ZlibCodec();

    protected internal StreamMode _streamMode = StreamMode.Undefined;
    protected internal FlushType _flushMode;
    protected internal ZlibStreamFlavor _flavor;
    protected internal CompressionMode _compressionMode;
    protected internal CompressionLevel _level;
    protected internal bool _leaveOpen;
    protected internal byte[] _workingBuffer;
    protected internal int _bufferSize = ZlibConstants.WorkingBufferSizeDefault;
    protected internal byte[] _buf1 = new byte[1];

    protected internal System.IO.Stream _stream;
    protected internal CompressionStrategy Strategy = CompressionStrategy.Default;

    // workitem 7159
    Ionic.Crc.CRC32 crc;
    protected internal string _GzipFileName;
    protected internal string _GzipComment;
    protected internal DateTime _GzipMtime;
    protected internal int _gzipHeaderByteCount;

    internal int Crc32 { get { if (crc == null) return 0; return crc.Crc32Result; } }

    public ZlibBaseStream(System.IO.Stream stream,
                          CompressionMode compressionMode,
                          CompressionLevel level,
                          ZlibStreamFlavor flavor,
                          bool leaveOpen)
        : base()
    {
      this._flushMode = FlushType.None;
      //this._workingBuffer = new byte[WORKING_BUFFER_SIZE_DEFAULT];
      this._stream = stream;
      this._leaveOpen = leaveOpen;
      this._compressionMode = compressionMode;
      this._flavor = flavor;
      this._level = level;
      // workitem 7159
      if (flavor == ZlibStreamFlavor.GZIP)
      {
        this.crc = new Ionic.Crc.CRC32();
      }
    }


    protected internal bool _wantCompress
    {
      get
      {
        return (this._compressionMode == CompressionMode.Compress);
      }
    }

    private ZlibCodec z
    {
      get
      {
        if (_z == null)
        {
          bool wantRfc1950Header = (this._flavor == ZlibStreamFlavor.ZLIB);
          _z = new ZlibCodec();
          if (this._compressionMode == CompressionMode.Decompress)
          {
            _z.InitializeInflate(wantRfc1950Header);
          }
          else
          {
            _z.Strategy = Strategy;
            _z.InitializeDeflate(this._level, wantRfc1950Header);
          }
        }
        return _z;
      }
    }



    private byte[] workingBuffer
    {
      get
      {
        if (_workingBuffer == null)
          _workingBuffer = new byte[_bufferSize];
        return _workingBuffer;
      }
    }



    public override void Write(System.Byte[] buffer, int offset, int count)
    {
      // workitem 7159
      // calculate the CRC on the unccompressed data  (before writing)
      if (crc != null)
        crc.SlurpBlock(buffer, offset, count);

      if (_streamMode == StreamMode.Undefined)
        _streamMode = StreamMode.Writer;
      else if (_streamMode != StreamMode.Writer)
        throw new ZlibException("Cannot Write after Reading.");

      if (count == 0)
        return;

      // first reference of z property will initialize the private var _z
      z.InputBuffer = buffer;
      _z.NextIn = offset;
      _z.AvailableBytesIn = count;
      bool done = false;
      do
      {
        _z.OutputBuffer = workingBuffer;
        _z.NextOut = 0;
        _z.AvailableBytesOut = _workingBuffer.Length;
        int rc = (_wantCompress)
            ? _z.Deflate(_flushMode)
            : _z.Inflate(_flushMode);
        if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
          throw new ZlibException((_wantCompress ? "de" : "in") + "flating: " + _z.Message);

        //if (_workingBuffer.Length - _z.AvailableBytesOut > 0)
        _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut);

        done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;

        // If GZIP and de-compress, we're done when 8 bytes remain.
        if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress)
          done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0);

      }
      while (!done);
    }



    private void finish()
    {
      if (_z == null) return;

      if (_streamMode == StreamMode.Writer)
      {
        bool done = false;
        do
        {
          _z.OutputBuffer = workingBuffer;
          _z.NextOut = 0;
          _z.AvailableBytesOut = _workingBuffer.Length;
          int rc = (_wantCompress)
              ? _z.Deflate(FlushType.Finish)
              : _z.Inflate(FlushType.Finish);

          if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK)
          {
            string verb = (_wantCompress ? "de" : "in") + "flating";
            if (_z.Message == null)
              throw new ZlibException(String.Format("{0}: (rc = {1})", verb, rc));
            else
              throw new ZlibException(verb + ": " + _z.Message);
          }

          if (_workingBuffer.Length - _z.AvailableBytesOut > 0)
          {
            _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut);
          }

          done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;
          // If GZIP and de-compress, we're done when 8 bytes remain.
          if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress)
            done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0);

        }
        while (!done);

        Flush();

        // workitem 7159
        if (_flavor == ZlibStreamFlavor.GZIP)
        {
          if (_wantCompress)
          {
            // Emit the GZIP trailer: CRC32 and  size mod 2^32
            int c1 = crc.Crc32Result;
            _stream.Write(BitConverter.GetBytes(c1), 0, 4);
            int c2 = (Int32)(crc.TotalBytesRead & 0x00000000FFFFFFFF);
            _stream.Write(BitConverter.GetBytes(c2), 0, 4);
          }
          else
          {
            throw new ZlibException("Writing with decompression is not supported.");
          }
        }
      }
      // workitem 7159
      else if (_streamMode == StreamMode.Reader)
      {
        if (_flavor == ZlibStreamFlavor.GZIP)
        {
          if (!_wantCompress)
          {
            // workitem 8501: handle edge case (decompress empty stream)
            if (_z.TotalBytesOut == 0L)
              return;

            // Read and potentially verify the GZIP trailer:
            // CRC32 and size mod 2^32
            byte[] trailer = new byte[8];

            // workitems 8679 & 12554
            if (_z.AvailableBytesIn < 8)
            {
              // Make sure we have read to the end of the stream
              Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, _z.AvailableBytesIn);
              int bytesNeeded = 8 - _z.AvailableBytesIn;
              int bytesRead = _stream.Read(trailer,
                                           _z.AvailableBytesIn,
                                           bytesNeeded);
              if (bytesNeeded != bytesRead)
              {
                throw new ZlibException(String.Format("Missing or incomplete GZIP trailer. Expected 8 bytes, got {0}.",
                                                      _z.AvailableBytesIn + bytesRead));
              }
            }
            else
            {
              Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, trailer.Length);
            }

            Int32 crc32_expected = BitConverter.ToInt32(trailer, 0);
            Int32 crc32_actual = crc.Crc32Result;
            Int32 isize_expected = BitConverter.ToInt32(trailer, 4);
            Int32 isize_actual = (Int32)(_z.TotalBytesOut & 0x00000000FFFFFFFF);

            if (crc32_actual != crc32_expected)
              throw new ZlibException(String.Format("Bad CRC32 in GZIP trailer. (actual({0:X8})!=expected({1:X8}))", crc32_actual, crc32_expected));

            if (isize_actual != isize_expected)
              throw new ZlibException(String.Format("Bad size in GZIP trailer. (actual({0})!=expected({1}))", isize_actual, isize_expected));

          }
          else
          {
            throw new ZlibException("Reading with compression is not supported.");
          }
        }
      }
    }


    private void end()
    {
      if (z == null)
        return;
      if (_wantCompress)
      {
        _z.EndDeflate();
      }
      else
      {
        _z.EndInflate();
      }
      _z = null;
    }


    public override void Close()
    {
      if (_stream == null) return;
      try
      {
        finish();
      }
      finally
      {
        end();
        if (!_leaveOpen) _stream.Close();
        _stream = null;
      }
    }

    public override void Flush()
    {
      _stream.Flush();
    }

    public override System.Int64 Seek(System.Int64 offset, System.IO.SeekOrigin origin)
    {
      throw new NotImplementedException();
      //_outStream.Seek(offset, origin);
    }
    public override void SetLength(System.Int64 value)
    {
      _stream.SetLength(value);
    }


#if NOT
        public int Read()
        {
            if (Read(_buf1, 0, 1) == 0)
                return 0;
            // calculate CRC after reading
            if (crc!=null)
                crc.SlurpBlock(_buf1,0,1);
            return (_buf1[0] & 0xFF);
        }
#endif

    private bool nomoreinput = false;



    private string ReadZeroTerminatedString()
    {
      var list = new System.Collections.Generic.List<byte>();
      bool done = false;
      do
      {
        // workitem 7740
        int n = _stream.Read(_buf1, 0, 1);
        if (n != 1)
          throw new ZlibException("Unexpected EOF reading GZIP header.");
        else
        {
          if (_buf1[0] == 0)
            done = true;
          else
            list.Add(_buf1[0]);
        }
      } while (!done);
      byte[] a = list.ToArray();
      return GZipStream.iso8859dash1.GetString(a, 0, a.Length);
    }


    private int _ReadAndValidateGzipHeader()
    {
      int totalBytesRead = 0;
      // read the header on the first read
      byte[] header = new byte[10];
      int n = _stream.Read(header, 0, header.Length);

      // workitem 8501: handle edge case (decompress empty stream)
      if (n == 0)
        return 0;

      if (n != 10)
        throw new ZlibException("Not a valid GZIP stream.");

      if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
        throw new ZlibException("Bad GZIP header.");

      Int32 timet = BitConverter.ToInt32(header, 4);
      _GzipMtime = GZipStream._unixEpoch.AddSeconds(timet);
      totalBytesRead += n;
      if ((header[3] & 0x04) == 0x04)
      {
        // read and discard extra field
        n = _stream.Read(header, 0, 2); // 2-byte length field
        totalBytesRead += n;

        Int16 extraLength = (Int16)(header[0] + header[1] * 256);
        byte[] extra = new byte[extraLength];
        n = _stream.Read(extra, 0, extra.Length);
        if (n != extraLength)
          throw new ZlibException("Unexpected end-of-file reading GZIP header.");
        totalBytesRead += n;
      }
      if ((header[3] & 0x08) == 0x08)
        _GzipFileName = ReadZeroTerminatedString();
      if ((header[3] & 0x10) == 0x010)
        _GzipComment = ReadZeroTerminatedString();
      if ((header[3] & 0x02) == 0x02)
#pragma warning disable
        Read(_buf1, 0, 1); // CRC16, ignore
#pragma warning restore

      return totalBytesRead;
    }



    public override System.Int32 Read(System.Byte[] buffer, System.Int32 offset, System.Int32 count)
    {
      // According to MS documentation, any implementation of the IO.Stream.Read function must:
      // (a) throw an exception if offset & count reference an invalid part of the buffer,
      //     or if count < 0, or if buffer is null
      // (b) return 0 only upon EOF, or if count = 0
      // (c) if not EOF, then return at least 1 byte, up to <count> bytes

      if (_streamMode == StreamMode.Undefined)
      {
        if (!this._stream.CanRead) throw new ZlibException("The stream is not readable.");
        // for the first read, set up some controls.
        _streamMode = StreamMode.Reader;
        // (The first reference to _z goes through the private accessor which
        // may initialize it.)
        z.AvailableBytesIn = 0;
        if (_flavor == ZlibStreamFlavor.GZIP)
        {
          _gzipHeaderByteCount = _ReadAndValidateGzipHeader();
          // workitem 8501: handle edge case (decompress empty stream)
          if (_gzipHeaderByteCount == 0)
            return 0;
        }
      }

      if (_streamMode != StreamMode.Reader)
        throw new ZlibException("Cannot Read after Writing.");

      if (count == 0) return 0;
      if (nomoreinput && _wantCompress) return 0;  // workitem 8557
      if (buffer == null) throw new ArgumentNullException("buffer");
      if (count < 0) throw new ArgumentOutOfRangeException("count");
      if (offset < buffer.GetLowerBound(0)) throw new ArgumentOutOfRangeException("offset");
      if ((offset + count) > buffer.GetLength(0)) throw new ArgumentOutOfRangeException("count");

      int rc = 0;

      // set up the output of the deflate/inflate codec:
      _z.OutputBuffer = buffer;
      _z.NextOut = offset;
      _z.AvailableBytesOut = count;

      // This is necessary in case _workingBuffer has been resized. (new byte[])
      // (The first reference to _workingBuffer goes through the private accessor which
      // may initialize it.)
      _z.InputBuffer = workingBuffer;

      do
      {
        // need data in _workingBuffer in order to deflate/inflate.  Here, we check if we have any.
        if ((_z.AvailableBytesIn == 0) && (!nomoreinput))
        {
          // No data available, so try to Read data from the captive stream.
          _z.NextIn = 0;
          _z.AvailableBytesIn = _stream.Read(_workingBuffer, 0, _workingBuffer.Length);
          if (_z.AvailableBytesIn == 0)
            nomoreinput = true;

        }
        // we have data in InputBuffer; now compress or decompress as appropriate
        rc = (_wantCompress)
            ? _z.Deflate(_flushMode)
            : _z.Inflate(_flushMode);

        if (nomoreinput && (rc == ZlibConstants.Z_BUF_ERROR))
          return 0;

        if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
          throw new ZlibException(String.Format("{0}flating:  rc={1}  msg={2}", (_wantCompress ? "de" : "in"), rc, _z.Message));

        if ((nomoreinput || rc == ZlibConstants.Z_STREAM_END) && (_z.AvailableBytesOut == count))
          break; // nothing more to read
      }
      //while (_z.AvailableBytesOut == count && rc == ZlibConstants.Z_OK);
      while (_z.AvailableBytesOut > 0 && !nomoreinput && rc == ZlibConstants.Z_OK);


      // workitem 8557
      // is there more room in output?
      if (_z.AvailableBytesOut > 0)
      {
        if (rc == ZlibConstants.Z_OK && _z.AvailableBytesIn == 0)
        {
          // deferred
        }

        // are we completely done reading?
        if (nomoreinput)
        {
          // and in compression?
          if (_wantCompress)
          {
            // no more input data available; therefore we flush to
            // try to complete the read
            rc = _z.Deflate(FlushType.Finish);

            if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
              throw new ZlibException(String.Format("Deflating:  rc={0}  msg={1}", rc, _z.Message));
          }
        }
      }


      rc = (count - _z.AvailableBytesOut);

      // calculate CRC after reading
      if (crc != null)
        crc.SlurpBlock(buffer, offset, rc);

      return rc;
    }



    public override System.Boolean CanRead
    {
      get { return this._stream.CanRead; }
    }

    public override System.Boolean CanSeek
    {
      get { return this._stream.CanSeek; }
    }

    public override System.Boolean CanWrite
    {
      get { return this._stream.CanWrite; }
    }

    public override System.Int64 Length
    {
      get { return _stream.Length; }
    }

    public override long Position
    {
      get { throw new NotImplementedException(); }
      set { throw new NotImplementedException(); }
    }

    internal enum StreamMode
    {
      Writer,
      Reader,
      Undefined,
    }


    public static void CompressString(String s, Stream compressor)
    {
      byte[] uncompressed = System.Text.Encoding.UTF8.GetBytes(s);
      using (compressor)
      {
        compressor.Write(uncompressed, 0, uncompressed.Length);
      }
    }

    public static void CompressBuffer(byte[] b, Stream compressor)
    {
      // workitem 8460
      using (compressor)
      {
        compressor.Write(b, 0, b.Length);
      }
    }

    public static String UncompressString(byte[] compressed, Stream decompressor)
    {
      // workitem 8460
      byte[] working = new byte[1024];
      var encoding = System.Text.Encoding.UTF8;
      using (var output = new MemoryStream())
      {
        using (decompressor)
        {
          int n;
          while ((n = decompressor.Read(working, 0, working.Length)) != 0)
          {
            output.Write(working, 0, n);
          }
        }

        // reset to allow read from start
        output.Seek(0, SeekOrigin.Begin);
        var sr = new StreamReader(output, encoding);
        return sr.ReadToEnd();
      }
    }

    public static byte[] UncompressBuffer(byte[] compressed, Stream decompressor)
    {
      // workitem 8460
      byte[] working = new byte[1024];
      using (var output = new MemoryStream())
      {
        using (decompressor)
        {
          int n;
          while ((n = decompressor.Read(working, 0, working.Length)) != 0)
          {
            output.Write(working, 0, n);
          }
        }
        return output.ToArray();
      }
    }

  }


}
